home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_random.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  18.5 KB  |  600 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import unittest
  5. import random
  6. import time
  7. import pickle
  8. import warnings
  9. from math import log, exp, sqrt, pi
  10. from test import test_support
  11.  
  12. class TestBasicOps(unittest.TestCase):
  13.     
  14.     def randomlist(self, n):
  15.         '''Helper function to make a list of random numbers'''
  16.         return [ self.gen.random() for i in xrange(n) ]
  17.  
  18.     
  19.     def test_autoseed(self):
  20.         self.gen.seed()
  21.         state1 = self.gen.getstate()
  22.         time.sleep(0.10000000000000001)
  23.         self.gen.seed()
  24.         state2 = self.gen.getstate()
  25.         self.assertNotEqual(state1, state2)
  26.  
  27.     
  28.     def test_saverestore(self):
  29.         N = 1000
  30.         self.gen.seed()
  31.         state = self.gen.getstate()
  32.         randseq = self.randomlist(N)
  33.         self.gen.setstate(state)
  34.         self.assertEqual(randseq, self.randomlist(N))
  35.  
  36.     
  37.     def test_seedargs(self):
  38.         for arg in [
  39.             None,
  40.             0,
  41.             0x0L,
  42.             1,
  43.             0x1L,
  44.             -1,
  45.             -0x1L,
  46.             10 ** 20,
  47.             -10 ** 20,
  48.             3.1400000000000001,
  49.             1 + (0.0+2.0j),
  50.             'a',
  51.             tuple('abc')]:
  52.             self.gen.seed(arg)
  53.         
  54.         for arg in [
  55.             range(3),
  56.             dict(one = 1)]:
  57.             self.assertRaises(TypeError, self.gen.seed, arg)
  58.         
  59.         self.assertRaises(TypeError, self.gen.seed, 1, 2)
  60.         self.assertRaises(TypeError, type(self.gen), [])
  61.  
  62.     
  63.     def test_jumpahead(self):
  64.         self.gen.seed()
  65.         state1 = self.gen.getstate()
  66.         self.gen.jumpahead(100)
  67.         state2 = self.gen.getstate()
  68.         self.assertNotEqual(state1, state2)
  69.         self.gen.jumpahead(100)
  70.         state3 = self.gen.getstate()
  71.         self.assertNotEqual(state2, state3)
  72.         self.assertRaises(TypeError, self.gen.jumpahead)
  73.         self.assertRaises(TypeError, self.gen.jumpahead, 'ick')
  74.         self.assertRaises(TypeError, self.gen.jumpahead, 2.2999999999999998)
  75.         self.assertRaises(TypeError, self.gen.jumpahead, 2, 3)
  76.  
  77.     
  78.     def test_sample(self):
  79.         N = 100
  80.         population = xrange(N)
  81.         for k in xrange(N + 1):
  82.             s = self.gen.sample(population, k)
  83.             self.assertEqual(len(s), k)
  84.             uniq = set(s)
  85.             self.assertEqual(len(uniq), k)
  86.             self.failUnless(uniq <= set(population))
  87.         
  88.         self.assertEqual(self.gen.sample([], 0), [])
  89.  
  90.     
  91.     def test_sample_distribution(self):
  92.         n = 5
  93.         pop = range(n)
  94.         trials = 10000
  95.         
  96.         def factorial(n):
  97.             return reduce(int.__mul__, xrange(1, n), 1)
  98.  
  99.         for k in xrange(n):
  100.             expected = factorial(n) // factorial(n - k)
  101.             perms = { }
  102.             for i in xrange(trials):
  103.                 perms[tuple(self.gen.sample(pop, k))] = None
  104.                 if len(perms) == expected:
  105.                     break
  106.                     continue
  107.             
  108.         
  109.  
  110.     
  111.     def test_sample_inputs(self):
  112.         self.gen.sample(set(range(20)), 2)
  113.         self.gen.sample(range(20), 2)
  114.         self.gen.sample(xrange(20), 2)
  115.         self.gen.sample(dict.fromkeys('abcdefghijklmnopqrst'), 2)
  116.         self.gen.sample(str('abcdefghijklmnopqrst'), 2)
  117.         self.gen.sample(tuple('abcdefghijklmnopqrst'), 2)
  118.  
  119.     
  120.     def test_gauss(self):
  121.         for seed in (1, 12, 123, 1234, 12345, 123456, 654321):
  122.             self.gen.seed(seed)
  123.             x1 = self.gen.random()
  124.             y1 = self.gen.gauss(0, 1)
  125.             self.gen.seed(seed)
  126.             x2 = self.gen.random()
  127.             y2 = self.gen.gauss(0, 1)
  128.             self.assertEqual(x1, x2)
  129.             self.assertEqual(y1, y2)
  130.         
  131.  
  132.     
  133.     def test_pickling(self):
  134.         state = pickle.dumps(self.gen)
  135.         origseq = [ self.gen.random() for i in xrange(10) ]
  136.         newgen = pickle.loads(state)
  137.         restoredseq = [ newgen.random() for i in xrange(10) ]
  138.         self.assertEqual(origseq, restoredseq)
  139.  
  140.  
  141.  
  142. class WichmannHill_TestBasicOps(TestBasicOps):
  143.     gen = random.WichmannHill()
  144.     
  145.     def test_setstate_first_arg(self):
  146.         self.assertRaises(ValueError, self.gen.setstate, (2, None, None))
  147.  
  148.     
  149.     def test_strong_jumpahead(self):
  150.         N = 1000
  151.         s = self.gen.getstate()
  152.         self.gen.jumpahead(N)
  153.         r1 = self.gen.random()
  154.         self.gen.setstate(s)
  155.         for i in xrange(N):
  156.             self.gen.random()
  157.         
  158.         r2 = self.gen.random()
  159.         self.assertEqual(r1, r2)
  160.  
  161.     
  162.     def test_gauss_with_whseed(self):
  163.         for seed in (1, 12, 123, 1234, 12345, 123456, 654321):
  164.             self.gen.whseed(seed)
  165.             x1 = self.gen.random()
  166.             y1 = self.gen.gauss(0, 1)
  167.             self.gen.whseed(seed)
  168.             x2 = self.gen.random()
  169.             y2 = self.gen.gauss(0, 1)
  170.             self.assertEqual(x1, x2)
  171.             self.assertEqual(y1, y2)
  172.         
  173.  
  174.     
  175.     def test_bigrand(self):
  176.         oldfilters = warnings.filters[:]
  177.         warnings.filterwarnings('error', 'Underlying random')
  178.         self.assertRaises(UserWarning, self.gen.randrange, 2 ** 60)
  179.         warnings.filters[:] = oldfilters
  180.  
  181.  
  182.  
  183. class SystemRandom_TestBasicOps(TestBasicOps):
  184.     gen = random.SystemRandom()
  185.     
  186.     def test_autoseed(self):
  187.         self.gen.seed()
  188.  
  189.     
  190.     def test_saverestore(self):
  191.         self.assertRaises(NotImplementedError, self.gen.getstate)
  192.         self.assertRaises(NotImplementedError, self.gen.setstate, None)
  193.  
  194.     
  195.     def test_seedargs(self):
  196.         self.gen.seed(100)
  197.  
  198.     
  199.     def test_jumpahead(self):
  200.         self.gen.jumpahead(100)
  201.  
  202.     
  203.     def test_gauss(self):
  204.         self.gen.gauss_next = None
  205.         self.gen.seed(100)
  206.         self.assertEqual(self.gen.gauss_next, None)
  207.  
  208.     
  209.     def test_pickling(self):
  210.         self.assertRaises(NotImplementedError, pickle.dumps, self.gen)
  211.  
  212.     
  213.     def test_53_bits_per_float(self):
  214.         span = 2 ** 53
  215.         cum = 0
  216.         for i in xrange(100):
  217.             cum |= int(self.gen.random() * span)
  218.         
  219.         self.assertEqual(cum, span - 1)
  220.  
  221.     
  222.     def test_bigrand(self):
  223.         span = 2 ** 500
  224.         cum = 0
  225.         for i in xrange(100):
  226.             r = self.gen.randrange(span)
  227.             None(self.assert_ if r <= r else r < span)
  228.             cum |= r
  229.         
  230.         self.assertEqual(cum, span - 1)
  231.  
  232.     
  233.     def test_bigrand_ranges(self):
  234.         for i in [
  235.             40,
  236.             80,
  237.             160,
  238.             200,
  239.             211,
  240.             250,
  241.             375,
  242.             512,
  243.             550]:
  244.             start = self.gen.randrange(2 ** i)
  245.             stop = self.gen.randrange(2 ** (i - 2))
  246.             if stop <= start:
  247.                 return None
  248.             
  249.             None(self.assert_ if self.gen.randrange(start, stop) <= self.gen.randrange(start, stop) else self.gen.randrange(start, stop) < stop)
  250.         
  251.  
  252.     
  253.     def test_rangelimits(self):
  254.         for start, stop in [
  255.             (-2, 0),
  256.             (-2 ** 60 - 2, -2 ** 60),
  257.             (2 ** 60, 2 ** 60 + 2)]:
  258.             set([], []([ self.gen.randrange(start, stop) for i in xrange(100) ]))
  259.         
  260.  
  261.     
  262.     def test_genrandbits(self):
  263.         for k in xrange(1, 1000):
  264.             None(self.assert_ if self.gen.getrandbits(k) <= self.gen.getrandbits(k) else self.gen.getrandbits(k) < 2 ** k)
  265.         
  266.         getbits = self.gen.getrandbits
  267.         for span in [
  268.             1,
  269.             2,
  270.             3,
  271.             4,
  272.             31,
  273.             32,
  274.             32,
  275.             52,
  276.             53,
  277.             54,
  278.             119,
  279.             127,
  280.             128,
  281.             129]:
  282.             cum = 0
  283.             for i in xrange(100):
  284.                 cum |= getbits(span)
  285.             
  286.             self.assertEqual(cum, 2 ** span - 1)
  287.         
  288.         self.assertRaises(TypeError, self.gen.getrandbits)
  289.         self.assertRaises(TypeError, self.gen.getrandbits, 1, 2)
  290.         self.assertRaises(ValueError, self.gen.getrandbits, 0)
  291.         self.assertRaises(ValueError, self.gen.getrandbits, -1)
  292.         self.assertRaises(TypeError, self.gen.getrandbits, 10.1)
  293.  
  294.     
  295.     def test_randbelow_logic(self, _log = log, int = int):
  296.         for i in xrange(1, 1000):
  297.             n = 0x1L << i
  298.             numbits = i + 1
  299.             k = int(1.0000100000000001 + _log(n, 2))
  300.             self.assertEqual(k, numbits)
  301.             self.assert_(n == 2 ** (k - 1))
  302.             n += n - 1
  303.             k = int(1.0000100000000001 + _log(n, 2))
  304.             self.assert_(k in [
  305.                 numbits,
  306.                 numbits + 1])
  307.             None(self.assert_ if n > n else n > 2 ** (k - 2))
  308.             n -= n >> 15
  309.             k = int(1.0000100000000001 + _log(n, 2))
  310.             self.assertEqual(k, numbits)
  311.             None(self.assert_ if n > n else n > 2 ** (k - 1))
  312.         
  313.  
  314.  
  315.  
  316. class MersenneTwister_TestBasicOps(TestBasicOps):
  317.     gen = random.Random()
  318.     
  319.     def test_setstate_first_arg(self):
  320.         self.assertRaises(ValueError, self.gen.setstate, (1, None, None))
  321.  
  322.     
  323.     def test_setstate_middle_arg(self):
  324.         self.assertRaises(TypeError, self.gen.setstate, (2, None, None))
  325.         self.assertRaises(ValueError, self.gen.setstate, (2, (1, 2, 3), None))
  326.         self.assertRaises(TypeError, self.gen.setstate, (2, ('a',) * 625, None))
  327.         self.assertRaises(TypeError, self.gen.setstate, (2, (0,) * 624 + ('a',), None))
  328.  
  329.     
  330.     def test_referenceImplementation(self):
  331.         expected = [
  332.             0.45839803073713259,
  333.             0.86057815201978782,
  334.             0.92848331726782152,
  335.             0.35932681119782461,
  336.             0.081823493762449573,
  337.             0.14332226470169329,
  338.             0.084297823823520024,
  339.             0.53814864671831453,
  340.             0.089215024911993401,
  341.             0.78486196105372907]
  342.         self.gen.seed(0xF123L + (0x6147L << 32) + (0x266L << 64) + (0xA49FL << 96))
  343.         actual = self.randomlist(2000)[-10:]
  344.         for a, e in zip(actual, expected):
  345.             self.assertAlmostEqual(a, e, places = 14)
  346.         
  347.  
  348.     
  349.     def test_strong_reference_implementation(self):
  350.         ldexp = ldexp
  351.         import math
  352.         expected = [
  353.             0xEAB3258D2231FL,
  354.             0x1B89DB315277A5L,
  355.             0x1DB622A5518016L,
  356.             0xB7F9AF0D575BFL,
  357.             0x29E4C4DB82240L,
  358.             0x4961892F5D673L,
  359.             0x2B291598E4589L,
  360.             0x11388382C15694L,
  361.             0x2DAD977C9E1FEL,
  362.             0x191D96D4D334C6L]
  363.         self.gen.seed(0xF123L + (0x6147L << 32) + (0x266L << 64) + (0xA49FL << 96))
  364.         actual = self.randomlist(2000)[-10:]
  365.         for a, e in zip(actual, expected):
  366.             self.assertEqual(long(ldexp(a, 53)), e)
  367.         
  368.  
  369.     
  370.     def test_long_seed(self):
  371.         seed = (0x1L << 10000 * 8) - 1
  372.         self.gen.seed(seed)
  373.  
  374.     
  375.     def test_53_bits_per_float(self):
  376.         span = 2 ** 53
  377.         cum = 0
  378.         for i in xrange(100):
  379.             cum |= int(self.gen.random() * span)
  380.         
  381.         self.assertEqual(cum, span - 1)
  382.  
  383.     
  384.     def test_bigrand(self):
  385.         span = 2 ** 500
  386.         cum = 0
  387.         for i in xrange(100):
  388.             r = self.gen.randrange(span)
  389.             None(self.assert_ if r <= r else r < span)
  390.             cum |= r
  391.         
  392.         self.assertEqual(cum, span - 1)
  393.  
  394.     
  395.     def test_bigrand_ranges(self):
  396.         for i in [
  397.             40,
  398.             80,
  399.             160,
  400.             200,
  401.             211,
  402.             250,
  403.             375,
  404.             512,
  405.             550]:
  406.             start = self.gen.randrange(2 ** i)
  407.             stop = self.gen.randrange(2 ** (i - 2))
  408.             if stop <= start:
  409.                 return None
  410.             
  411.             None(self.assert_ if self.gen.randrange(start, stop) <= self.gen.randrange(start, stop) else self.gen.randrange(start, stop) < stop)
  412.         
  413.  
  414.     
  415.     def test_rangelimits(self):
  416.         for start, stop in [
  417.             (-2, 0),
  418.             (-2 ** 60 - 2, -2 ** 60),
  419.             (2 ** 60, 2 ** 60 + 2)]:
  420.             set([], []([ self.gen.randrange(start, stop) for i in xrange(100) ]))
  421.         
  422.  
  423.     
  424.     def test_genrandbits(self):
  425.         self.gen.seed(1234567)
  426.         self.assertEqual(self.gen.getrandbits(100), 0x13C58FD846EC5C07FF6908E53L)
  427.         for k in xrange(1, 1000):
  428.             None(self.assert_ if self.gen.getrandbits(k) <= self.gen.getrandbits(k) else self.gen.getrandbits(k) < 2 ** k)
  429.         
  430.         getbits = self.gen.getrandbits
  431.         for span in [
  432.             1,
  433.             2,
  434.             3,
  435.             4,
  436.             31,
  437.             32,
  438.             32,
  439.             52,
  440.             53,
  441.             54,
  442.             119,
  443.             127,
  444.             128,
  445.             129]:
  446.             cum = 0
  447.             for i in xrange(100):
  448.                 cum |= getbits(span)
  449.             
  450.             self.assertEqual(cum, 2 ** span - 1)
  451.         
  452.         self.assertRaises(TypeError, self.gen.getrandbits)
  453.         self.assertRaises(TypeError, self.gen.getrandbits, 'a')
  454.         self.assertRaises(TypeError, self.gen.getrandbits, 1, 2)
  455.         self.assertRaises(ValueError, self.gen.getrandbits, 0)
  456.         self.assertRaises(ValueError, self.gen.getrandbits, -1)
  457.  
  458.     
  459.     def test_randbelow_logic(self, _log = log, int = int):
  460.         for i in xrange(1, 1000):
  461.             n = 0x1L << i
  462.             numbits = i + 1
  463.             k = int(1.0000100000000001 + _log(n, 2))
  464.             self.assertEqual(k, numbits)
  465.             self.assert_(n == 2 ** (k - 1))
  466.             n += n - 1
  467.             k = int(1.0000100000000001 + _log(n, 2))
  468.             self.assert_(k in [
  469.                 numbits,
  470.                 numbits + 1])
  471.             None(self.assert_ if n > n else n > 2 ** (k - 2))
  472.             n -= n >> 15
  473.             k = int(1.0000100000000001 + _log(n, 2))
  474.             self.assertEqual(k, numbits)
  475.             None(self.assert_ if n > n else n > 2 ** (k - 1))
  476.         
  477.  
  478.  
  479. _gammacoeff = (0.99999999999951827, 676.52036812188351, -1259.1392167222889, 771.32342877576741, -176.61502914983859, 12.50734324009056, -0.1385710331296526, 9.9349371139307475e-06, 1.6594701874084621e-07)
  480.  
  481. def gamma(z, cof = _gammacoeff, g = 7):
  482.     z -= 1.0
  483.     sum = cof[0]
  484.     for i in xrange(1, len(cof)):
  485.         sum += cof[i] / (z + i)
  486.     
  487.     z += 0.5
  488.     return ((z + g) ** z / exp(z + g)) * sqrt(2 * pi) * sum
  489.  
  490.  
  491. class TestDistributions(unittest.TestCase):
  492.     
  493.     def test_zeroinputs(self):
  494.         g = random.Random()
  495.         x = [ g.random() for i in xrange(50) ] + [
  496.             0.0] * 5
  497.         g.random = x[:].pop
  498.         g.uniform(1, 10)
  499.         g.random = x[:].pop
  500.         g.paretovariate(1.0)
  501.         g.random = x[:].pop
  502.         g.expovariate(1.0)
  503.         g.random = x[:].pop
  504.         g.weibullvariate(1.0, 1.0)
  505.         g.random = x[:].pop
  506.         g.normalvariate(0.0, 1.0)
  507.         g.random = x[:].pop
  508.         g.gauss(0.0, 1.0)
  509.         g.random = x[:].pop
  510.         g.lognormvariate(0.0, 1.0)
  511.         g.random = x[:].pop
  512.         g.vonmisesvariate(0.0, 1.0)
  513.         g.random = x[:].pop
  514.         g.gammavariate(0.01, 1.0)
  515.         g.random = x[:].pop
  516.         g.gammavariate(1.0, 1.0)
  517.         g.random = x[:].pop
  518.         g.gammavariate(200.0, 1.0)
  519.         g.random = x[:].pop
  520.         g.betavariate(3.0, 3.0)
  521.  
  522.     
  523.     def test_avg_std(self):
  524.         g = random.Random()
  525.         N = 5000
  526.         x = [ i / float(N) for i in xrange(1, N) ]
  527.         for variate, args, mu, sigmasqrd in [
  528.             (g.uniform, (1.0, 10.0), (10.0 + 1.0) / 2, (10.0 - 1.0) ** 2 / 12),
  529.             (g.expovariate, (1.5,), 1 / 1.5, 1 / 1.5 ** 2),
  530.             (g.paretovariate, (5.0,), 5.0 / (5.0 - 1), 5.0 / ((5.0 - 1) ** 2 * (5.0 - 2))),
  531.             (g.weibullvariate, (1.0, 3.0), gamma(1 + 1 / 3.0), gamma(1 + 2 / 3.0) - gamma(1 + 1 / 3.0) ** 2)]:
  532.             g.random = x[:].pop
  533.             y = []
  534.             for i in xrange(len(x)):
  535.                 
  536.                 try:
  537.                     y.append(variate(*args))
  538.                 continue
  539.                 except IndexError:
  540.                     []
  541.                     []
  542.                     []
  543.                     continue
  544.                 
  545.  
  546.             
  547.             for e in y:
  548.                 s1 += e
  549.                 s2 += (e - mu) ** 2
  550.             
  551.             N = len(y)
  552.             self.assertAlmostEqual(s1 / N, mu, 2)
  553.             self.assertAlmostEqual(s2 / (N - 1), sigmasqrd, 2)
  554.         
  555.  
  556.  
  557.  
  558. class TestModule(unittest.TestCase):
  559.     
  560.     def testMagicConstants(self):
  561.         self.assertAlmostEqual(random.NV_MAGICCONST, 1.71552776992141)
  562.         self.assertAlmostEqual(random.TWOPI, 6.2831853071800001)
  563.         self.assertAlmostEqual(random.LOG4, 1.3862943611198899)
  564.         self.assertAlmostEqual(random.SG_MAGICCONST, 2.5040773967762702)
  565.  
  566.     
  567.     def test__all__(self):
  568.         self.failUnless(set(random.__all__) <= set(dir(random)))
  569.  
  570.  
  571.  
  572. def test_main(verbose = None):
  573.     testclasses = [
  574.         WichmannHill_TestBasicOps,
  575.         MersenneTwister_TestBasicOps,
  576.         TestDistributions,
  577.         TestModule]
  578.     
  579.     try:
  580.         random.SystemRandom().random()
  581.     except NotImplementedError:
  582.         pass
  583.  
  584.     testclasses.append(SystemRandom_TestBasicOps)
  585.     test_support.run_unittest(*testclasses)
  586.     import sys
  587.     if verbose and hasattr(sys, 'gettotalrefcount'):
  588.         counts = [
  589.             None] * 5
  590.         for i in xrange(len(counts)):
  591.             test_support.run_unittest(*testclasses)
  592.             counts[i] = sys.gettotalrefcount()
  593.         
  594.         print counts
  595.     
  596.  
  597. if __name__ == '__main__':
  598.     test_main(verbose = True)
  599.  
  600.